#include <iostream>
using namespace std;
// int main() {
//     // 左值可以被取地址
//     // 下面的变量都是常见的左值
//     int* p = new int(1);
//     int x = 1;
//     const int y = x;
//     *p = 2;
//     string s("hello world!");
//     s[0] = 'H';
//     cout << &y << endl; // 可以取地址
//     return 0;
// }

// int main() {
//     // 右值不能取地址
//     double x = 1.2, y = 3.4;
//     // 下面就是几个比较常见的右值了
//     1;
//     x + y;
//     fmin(x, y);
//     string("hello world!");
//     cout << &1 << endl; // 不能取地址，其他的也是，会报错
//     return 0;
// }


// #include <iostream>
// using namespace std;
// int main() {
//     // 这些都是我们常见的左值
//     int* p = new int(1);
//     int x = 1;
//     const int y = x;
//     *p = 2;
//     string s("hello world!");
//     s[0] = 'H';
//     double m = 1.2, n = 3.4;

//     // 左值引用
//     int*& r1 = p;
//     int& r2 = x;
//     int& r3 = *p;
//     string& r4 = s;
//     char& r5 = s[0];
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int main() {
//     double m = 1.2, n = 3.4;
//     int&& rr1 = 1;
//     double&& rr2 = m + n;
//     double&& rr3 = fmin(x, y);
//     string&& rr4 = string("hello world");
//     return 0;
// }


// #include <iostream>
// using namespace std;
// int main() {
//     double m = 1.2, n = 3.4;
//     int&& rr1 = 1;
//     const int& rx1 = 10;
//     const double& rx2 = n + m;
//     const doubel& rx3 = fmin(n, m);
//     const string& rx4 = string("hello world!");
//     return 0;
// }


// #include <iostream>
// using namespace std;
// int main() {
//     int* p = new int(1);
//     int x = 1;
//     const int y = x;
//     *p = 2;
//     string s("hello world!");
//     s[0] = 'H';
//     double m = 1.2, n = 3.4;
//     int&& rrx1 = move(x);
//     int*&& rrx2 = move(p);
//     int&& rrx3 = move(*p);
//     string&& rrx4 = move(s);
//     return 0;
// }

// #include <iostream>
// using namespace std;
// int main() {
//     string s1 = "hello";
//     const string& r1 = s1 + s1; // 使用const左值引用延长了生命周期
//     string&& r2 = s1 + s1; // 使用了右值引用延长了生命周期
//     return 0;
// }


// #include <iostream>
// using namespace std;
// void f(int& x) {
//     cout << "左值引用" << endl;
// }
// void f(const int& x) {
//     cout << "const左值引用" << endl;
// }
// void f(int&& x) {
//     cout << "右值引用" << endl;
// }
// int main() {
//     int i = 1;
//     const int j = 2;
//     f(i);
//     f(j);
//     f(3); // 有f(int&& x)就调用f(int&& x)，没有就调用f(const int& x)
//     f(move(i));
//     int && x = 1;
//     f(x);
//     f(move(x));
//     return 0;
// }


// class Solution {
// public:
//     // 传值返回需要拷贝
//     string addStrings(string num1, string num2) {
//         string str;
//         int end1 = num1.size() - 1, end2 = num2.size() - 1;
//         int next = 0;
//         while (end1 >= 0 || end2 >= 0) {
//             int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//             int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
            
//             int ret = val1 + val2 + next;
//             next = ret / 10;
//             ret = ret % 10;
            
//             str += ('0' + ret);
//         }
//         if (next == 1) 
//             str += '1';
//         reverse(str.begin(), str.end());
//         return str;
//     }
// };
// class Solution {
// public:
//     // 这里也是使用的传值返回并且代价极大
//     vector<vector<int>> generate(int numRows) {
//         vector<vector<int>> vv(numRows);
//         for (int i = 0; i < numRows; ++i) {
//             vv[i].resize(i + 1, 1);
//         }
        
//         for (int i = 2; i < numRows; ++i) {
//             for (int j = 1; j < i; ++j) {
//                 vv[i][j] = vv[i-1][j-1] + vv[i-1][j];
//             }
//         }
        
//         return vv;
//     }
// };


// #include <iostream>
// using namespace std;
// namespace xywl {
//     class string {
//         public:
//             void swap(string& s) {
//                 ::swap(_str, s._str);
//                 ::swap(_size, s._size);
//                 ::swap(_capacity, s._capacity);
//             }
//             string(string&& s) {
//                 cout << "string(string&& s) -- 移动构造" << endl;
//                 swap(s);
//             }
//             string& operator=(string&& s) {
//                 cout << "string& operator=(string&& s) -- 移动赋值" << endl;
//                 swap(s);
//                 return *this;
//             }
//         private:
//             char* _str;
//             size_t _size;
//             size_t _capacity;
//     };
// }

// #include <iostream>
// #include <string>
// #include <algorithm>
// using namespace std;

// namespace xywl {
//     string addStrings(string num1, string num2) {
//         string str;
//         int end1 = num1.size() - 1, end2 = num2.size() - 1;
//         int next = 0;
//         while (end1 >= 0 || end2 >= 0) {
//             int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//             int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;

//             int ret = val1 + val2 + next;
//             next = ret / 10;
//             ret = ret % 10;

//             str += ('0' + ret);
//         }
//         if (next == 1)
//             str += '1';

//         reverse(str.begin(), str.end());

//         cout << "****************************" << endl;

//         return str;
//     }
// }

// // 场景1
// int main() {
//     xywl::string ret = xywl::addStrings("11111", "2222");
//     cout << ret.c_str() << endl;
//     return 0;
// }

// 场景2
// int main() {
//     bit::string ret;
//     ret = bit::addStrings("11111", "2222");
//     cout << ret.c_str() << endl;
//     return 0;
// }

// #include <iostream>
// using namespace std;
// template<class T>
// void f1(T& x) {}
// template<class T>
// void f2(T&& x) {}
// int main() {
//     typedef int& lref;
//     typedef int&& rref;
//     int n = 1;
//     lref& r1 = n; // 类型为int&
//     lref&& r2 = n; // 类型为int&
//     rref& r3 = n; // 类型为int&
//     rref&& r4 = 1; // 类型为int&&

//     // 没有折叠->实例化为 void f1(int& x)
//     f1<int>(n);
//     // f1<int>(0);  // 报错

//     // 折叠->实例化为 void f1(int& x)
//     f1<int&>(n);
//     // f1<int&>(0); // 报错

//     // 折叠->实例化为 void f1(int& x)
//     f1<int&&>(n);
//     // f1<int&&>(0); // 报错

//     // 折叠->实例化为 void f1(const int& x)
//     f1<const int&>(n);
//     f1<const int&>(0);

//     // 折叠->实例化为 void f1(const int& x)
//     f1<const int&&>(n);
//     f1<const int&&>(0);

//     // 没有折叠->实例化为 void f2(int&& x)
//     f2<int>(n);   // 报错
//     f2<int>(0);

//     // 折叠->实例化为 void f2(int& x)
//     f2<int&>(n);  // 报错
//     f2<int&>(0);

//     // 折叠->实例化为 void f2(int&& x)
//     f2<int&&>(n); // 报错
//     f2<int&&>(0);
//     return 0;
// }

// #include <iostream>
// #include <utility>
// using namespace std;

// template<class T>
// void Function(T&& t) {
//     int a = 0;
//     T x = a;
//     // x++;
//     cout << &a << endl;
//     cout << &x << endl << endl;
// }

// int main() {
//     // 10是右值，推导出T为int，模板实例化为void Function(int&& t)
//     Function(10); // 右值

//     int a;
//     // a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
//     Function(a); // 左值

//     // std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
//     Function(std::move(a)); // 右值

//     const int b = 8;
//     // b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)
//     // 所以Function内部会编译报错，x不能++
//     Function(b); // const 左值

//     // std::move(b)右值，推导出T为const int，模板实例化为void Function(const int&& t)
//     // 所以Function内部会编译报错，x不能++
//     Function(std::move(b)); // const 右值

//     return 0;
// }




// #include <iostream>
// #include <type_traits>
// using namespace std;
// void Fun(int& x) { cout << "左值引用" << endl; }
// void Fun(const int& x) { cout << "const 左值引用" << endl; }
// void Fun(int&& x) { cout << "右值引用" << endl; }
// void Fun(const int&& x) { cout << "const 右值引用" << endl; }
// template<class T>
// void Function(T&& t)
// {
//     Fun(forward<T>(t));
// }
// int main()
// {
//     // 10是右值，推导出T为int，模板实例化为void Function(int&& t)
//     Function(10);                         // 右值
//     int a;
//     // a是左值，推导出T为int&，引用折叠，模板实例化为void Function(int& t)
//     Function(a);                          // 左值
//     // std::move(a)是右值，推导出T为int，模板实例化为void Function(int&& t)
//     Function(std::move(a));               // 右值
//     const int b = 8;
//     // b是左值，推导出T为const int&，引用折叠，模板实例化为void Function(const int& t)
//     Function(b);                          // const 左值
//     // std::move(b)是右值，推导出T为const int，模板实例化为void Function(const int&& t)
//     Function(std::move(b));               // const 右值
//     return 0;
// }



// template <class _Ty>
// _Ty& forward(remove_reference_t<_Ty>& _Arg) noexcept
// {
//     // forward an lvalue as either an lvalue or an rvalue
//     return static_cast<_Ty&>(_Arg);
// }